What about using typing.get_type_hints to resolve annotations for a class?

It will allow having ClassVar annotated as str:

@runtime_checkable
class P(Protocol):
    x: 'ClassVar[int]' = 1

Good question! I'd considered that too but decided against it for two main reasons:

1. get_type_hints is slow
2. get_type_hints won't work with forward references/ PEP 563 if ClassVar is not defined in the caller's namespace

Consider the following:

# foo.py
from __future__ import annotations
from typing import *

@runtime_checkable
class X(Protocol):
 x: ClassVar[int] = 1
 y: SomeUndeclaredType = None

# bar.py
from .foo import X
class Y: ...

# Error! get_type_hints cannot resolve 'ClassVar' and 'SomeUndeclaredType'
issubclass(X, Y)

Nonetheless, your suggestion has reminded me of a basic workaround for string annotations. Thanks.

Let's also add a case with the same class prop, but different value. Example:

class E:
    x = 2

Because right now all names / values always match. It is not clear whether value is a part of the protocol or not.

Agreed.

It is not clear whether value is a part of the protocol or not.

It shouldn't be. IMO, we should only care about the "shape". Trying to runtime-check the value is difficult and should be left to third-party libs to do.

Nevermind, I changed my mind. Let's do it!

Let's also test these classes:

class G:
   x: ClassVar[int] = 1

class H:
   x: 'ClassVar[int]' = 1

These aren't testing more code paths, the code doesn't look at the annotations of the first class argument in issubclass.

This is incorrect. Consider this example:

class P(Protocol):
     x: ClassVar[object] = object()

class Y:
     x: ClassVar[object] = 1

Y implements protocol P, but your code rejects it. There are also problems with None here that could produce an incorrect result.

I'd recommend removing this whole check, and just checking that the attribute exists. Full runtime type checking is hard and the standard library shouldn't try to do it.